// projects/oa/pages/task/index/task_index.js
import { createStoreBindings } from 'mobx-miniprogram-bindings';
import { taskStore } from '../../../../../store/modules/task_store.js';
import { userStore } from '../../../../../store/global/user';
import pageHelper from '../../../../../helpers/page_helper';
import Day from 'dayjs';
const { logEvent } = require('../../../helpers/log_helper.js');
const { getNetworkStatus, listenNetworkStatus } = require('../../../helpers/network_helper.js');

Page({
	/**
	 * 页面的初始数据
	 */
	data: {
		// 界面控制
		isLoad: false,
		searchValue: '',
		activeTab: 'all',
		tabs: [
			{ id: 'all', name: '全部' },
			{ id: 'pending', name: '待处理' },
			{ id: 'processing', name: '处理中' },
			{ id: 'completed', name: '已完成' }
		],
		priorityLabels: {
			low: { text: '低', color: '#718096' },
			medium: { text: '中', color: '#4299E1' },
			high: { text: '高', color: '#F6AD55' },
			urgent: { text: '紧急', color: '#E53E3E' }
		},
		view: 'list', // 'list' or 'board'
		sortOptions: [
			{ field: 'updateTime', direction: 'desc', text: '更新时间 ↓' },
			{ field: 'updateTime', direction: 'asc', text: '更新时间 ↑' },
			{ field: 'dueDate', direction: 'asc', text: '截止日期 ↑' }, 
			{ field: 'dueDate', direction: 'desc', text: '截止日期 ↓' },
			{ field: 'priority', direction: 'desc', text: '优先级 ↓' }
		],
		currentSortIndex: 0,
		loadingMore: false,
		projectId: '',
		showFilterDrawer: false,
		hasSelectedTasks: false,
		startDate: '',
		endDate: ''
	},

	/**
	 * 生命周期函数--监听页面加载
	 */
	onLoad: async function(options) {
		// 网络检测
		const net = await getNetworkStatus();
		if (!net.isConnected) {
			wx.showToast({ title: '当前无网络，请检查连接', icon: 'none' });
		} else if (net.networkType === '2g') {
			wx.showToast({ title: '当前为2G弱网，体验可能受影响', icon: 'none' });
		}
		listenNetworkStatus((res) => {
			if (!res.isConnected) wx.showToast({ title: '网络已断开', icon: 'none' });
			else if (res.networkType === '2g') wx.showToast({ title: '当前为2G弱网', icon: 'none' });
		});
		logEvent('page_load', { page: 'task_index' });
		
		// 初始化任务Store
		await taskStore.init();
		
		// 创建task store绑定 - 仅绑定所需字段和方法，避免重复
		this.taskStoreBindings = createStoreBindings(this, {
			store: taskStore,
			fields: [
				'tasks',
				'loading',
				'error',
				'statistics',
				'pagination',
				'lastUpdate',
				'selectedTasks',
				'filters'
			]
		});
		
		// 创建user store绑定
		this.userStoreBindings = createStoreBindings(this, {
			store: userStore,
			fields: ['user', 'isLogin']
		});
		
		// 设置项目ID
		const projectId = options.projectId || '';
		if (projectId) {
			this.setData({ projectId });
			taskStore.setCurrentProjectId(projectId);
		}
		
		// 初始排序和视图
		const { sortOptions, currentSortIndex } = this.data;
		taskStore.setSorting(
			sortOptions[currentSortIndex].field, 
			sortOptions[currentSortIndex].direction
		);
		
		// 加载任务列表
		this._loadTaskList();
	},

	/**
	 * 生命周期函数--监听页面初次渲染完成
	 */
	onReady() {
		
	},

	/**
	 * 生命周期函数--监听页面显示
	 */
	onShow() {
		// 检查Store绑定是否存在，如果不存在则重新创建
		if (!this.taskStoreBindings) {
			console.warn('[任务列表] Store绑定不存在，尝试重新创建');
			// 创建task store绑定 - 仅绑定所需字段
			this.taskStoreBindings = createStoreBindings(this, {
				store: taskStore,
				fields: [
					'tasks',
					'loading',
					'error',
					'statistics',
					'pagination',
					'lastUpdate',
					'selectedTasks',
					'filters'
				]
			});
		}
		
		// 检查是否需要刷新数据
		this._checkAndRefreshData();
	},

	/**
	 * 检查是否需要刷新数据
	 */
	_checkAndRefreshData() {
		// 如果数据为空或最后更新时间超过5分钟，刷新数据
		const needRefresh = !this.data.tasks || !this.data.tasks.length || !this.data.lastUpdate;
		
		if (needRefresh) {
			// 直接使用taskStore对象的方法，而不是绑定的方法
			taskStore.refreshTasks().then(() => {
				// 刷新后更新预处理数据
				this._prepareTasksForBoard();
			}).catch(err => {
				console.error('[任务列表] 刷新失败:', err);
				// 即使刷新失败，也尝试处理现有数据
				this._prepareTasksForBoard();
			});
		} else {
			// 确保预处理数据始终是最新的
			this._prepareTasksForBoard();
		}
	},
	
	/**
	 * 加载任务列表
	 */
	async _loadTaskList() {
		try {
			const params = {
				page: 1
			};
			
			if (this.data.projectId) {
				await taskStore.getProjectTasks(this.data.projectId, params);
			} else {
				// 加载所有任务
				await taskStore.getProjectTasks('', params);
			}
			
			// 更新选中任务状态
			this._updateHasSelectedTasks();
			
			// 预处理任务数据用于看板视图
			this._prepareTasksForBoard();
			
			this.setData({
				isLoad: true
			});
		} catch (err) {
			console.error('[任务列表] 加载失败:', err);
			pageHelper.showErrToast('加载失败，请重试');
			this.setData({
				isLoad: true
			});
		}
	},

	/**
	 * 预处理任务数据用于看板视图
	 * 避免在WXML中使用复杂的数组过滤
	 */
	_prepareTasksForBoard() {
		const tasks = this.data.tasks || [];
		
		// 分类任务
		const pendingTasks = tasks.filter(task => task.status === 'pending');
		const inProgressTasks = tasks.filter(task => task.status === 'in_progress');
		const completedTasks = tasks.filter(task => task.status === 'completed');
		
		this.setData({
			pendingTasks,
			inProgressTasks,
			completedTasks
		});
	},

	/**
	 * 生命周期函数--监听页面隐藏
	 */
	onHide() {

	},

	/**
	 * 生命周期函数--监听页面卸载
	 */
	onUnload() {
		// 清理store绑定
		if (this.taskStoreBindings) {
			this.taskStoreBindings.destroyStoreBindings();
		}
		
		if (this.userStoreBindings) {
			this.userStoreBindings.destroyStoreBindings();
		}
	},

	/**
	 * 页面相关事件处理函数--监听用户下拉动作
	 */
	onPullDownRefresh() {
		taskStore.refreshTasks().then(() => {
			this._prepareTasksForBoard();
			wx.stopPullDownRefresh();
		}).catch(() => {
			wx.stopPullDownRefresh();
		});
	},

	/**
	 * 页面上拉触底事件的处理函数
	 */
	onReachBottom() {
		if (this.data.loading || !this.data.pagination.hasMore) return;
		
		this.setData({ loadingMore: true });
		
		taskStore.loadMoreTasks().then(() => {
			this._prepareTasksForBoard();
			this.setData({ loadingMore: false });
		}).catch(() => {
			this.setData({ loadingMore: false });
		});
	},

	/**
	 * 用户点击右上角分享
	 */
	onShareAppMessage() {
		return {
			title: '任务管理 - 高效协作平台',
			path: '/projects/oa/pages/task/index/task_index'
		};
	},

	/**
	 * 搜索输入处理
	 */
	onSearchInput(e) {
		const keyword = e.detail.value;
		this.setData({
			searchValue: keyword
		});
	},
	
	/**
	 * 搜索确认
	 */
	onSearchConfirm(e) {
		const keyword = e.detail.value;
		taskStore.searchTasks(keyword);
	},
	
	/**
	 * 清除搜索
	 */
	onSearchClear() {
		this.setData({
			searchValue: ''
		});
		taskStore.searchTasks('');
	},
	
	/**
	 * 切换标签页
	 */
	onTabChange(e) {
		let tab = e.currentTarget.dataset.tab;
		logEvent('switch_tab', { tab });
		this.setData({
			activeTab: tab
		});
		
		// 根据标签设置筛选条件
		const statusMap = {
			'all': 'all',
			'pending': 'pending',
			'processing': 'processing',
			'completed': 'completed'
		};
		
		// 使用MobX中的过滤方法
		taskStore.setFilters({ status: statusMap[tab] });
		
		// 刷新数据
		taskStore.refreshTasks();
	},
	
	/**
	 * 切换视图模式（列表/看板）
	 */
	onViewChange(e) {
		const view = e.currentTarget.dataset.view;
		this.setData({ view });
		taskStore.setView(view);
	},
	
	/**
	 * 切换排序方式
	 */
	onSortChange(e) {
		const index = e.detail.value;
		const option = this.data.sortOptions[index];
		
		this.setData({
			currentSortIndex: index
		});
		
		taskStore.setSorting(option.field, option.direction);
		taskStore.refreshTasks();
	},
	
	/**
	 * 跳转到任务详情
	 */
	onTaskTap(e) {
		const id = e.currentTarget.dataset.id;
		wx.navigateTo({
			url: `../detail/task_detail?id=${id}`
		});
	},
	
	/**
	 * 添加新任务
	 */
	onAddTask() {
		const url = this.data.projectId ? 
			`../edit/task_edit?projectId=${this.data.projectId}` : 
			'../edit/task_edit';
			
		wx.navigateTo({
			url
		, timeout: 10000, fail: function(err) {
        // 处理超时错误
        if (err.errMsg && err.errMsg.includes("timeout")) {
          wx.showToast({
            title: "页面加载超时，请重试",
            icon: "none"
          });
          return;
        }
        
        // 处理其他错误
        console.error("页面跳转失败:", err);
        wx.showToast({
          title: "页面跳转失败",
          icon: "none"
        });
      }});
	},
	
	/**
	 * 修改任务状态
	 */
	onStatusChange(e) {
		const id = e.currentTarget.dataset.id;
		const status = e.currentTarget.dataset.status;
		
		wx.showLoading({
			title: '更新中...',
			mask: true
		});
		
		taskStore.updateTaskStatus(id, status).then(() => {
			wx.hideLoading();
			pageHelper.showSuccToast('状态已更新');
		}).catch(err => {
			console.error('[任务列表] 状态更新失败:', err);
			wx.hideLoading();
			pageHelper.showErrToast('更新失败，请重试');
		});
	},
	
	/**
	 * 选择/取消选择任务
	 */
	onTaskSelect(e) {
		const id = e.currentTarget.dataset.id;
		taskStore.toggleTaskSelection(id);
		this._updateHasSelectedTasks();
	},
	
	/**
	 * 全选/取消全选
	 */
	onSelectAll(e) {
		const selected = e.detail.value.length > 0;
		taskStore.selectAllTasks(selected);
		this._updateHasSelectedTasks();
	},
	
	/**
	 * 批量操作
	 */
	onBatchOperation(e) {
		const operation = e.currentTarget.dataset.operation;
		
		if (operation === 'complete') {
			this._batchComplete();
		} else if (operation === 'delete') {
			this._batchDelete();
		}
	},
	
	/**
	 * 批量完成任务
	 */
	async _batchComplete() {
		if (this.data.selectedTasks.length === 0) {
			pageHelper.showNoneToast('请先选择任务');
			return;
		}
		
		const ids = this.data.selectedTasks;
		
		wx.showModal({
			title: '批量完成',
			content: `确认将选中的 ${ids.length} 个任务标记为已完成？`,
			success: async (res) => {
				if (res.confirm) {
					wx.showLoading({
						title: '处理中...',
						mask: true
					});
					
					try {
						await taskStore.batchUpdateTaskStatus(ids, 'completed');
						wx.hideLoading();
						pageHelper.showSuccToast('操作成功');
					} catch (err) {
						console.error('[任务列表] 批量完成失败:', err);
						wx.hideLoading();
						pageHelper.showErrToast('操作失败，请重试');
					}
				}
			}
		});
	},
	
	/**
	 * 批量删除任务
	 */
	async _batchDelete() {
		if (this.data.selectedTasks.length === 0) {
			pageHelper.showNoneToast('请先选择任务');
			return;
		}
		
		const ids = this.data.selectedTasks;
		
		wx.showModal({
			title: '批量删除',
			content: `确认删除选中的 ${ids.length} 个任务？此操作不可恢复！`,
			success: async (res) => {
				if (res.confirm) {
					wx.showLoading({
						title: '删除中...',
						mask: true
					});
					
					try {
						for (const id of ids) {
							await taskStore.deleteTask(id);
						}
						
						wx.hideLoading();
						pageHelper.showSuccToast('删除成功');
					} catch (err) {
						console.error('[任务列表] 批量删除失败:', err);
						wx.hideLoading();
						pageHelper.showErrToast('删除失败，请重试');
					}
				}
			}
		});
	},
	
	/**
	 * 更新是否有选中任务的状态
	 */
	_updateHasSelectedTasks() {
		this.setData({
			hasSelectedTasks: this.data.selectedTasks && this.data.selectedTasks.length > 0
		});
	},
	
	/**
	 * 显示筛选抽屉
	 */
	onShowFilter() {
		this.setData({
			showFilterDrawer: true,
			startDate: this.data.filters.dateRange ? this.data.filters.dateRange[0] : '',
			endDate: this.data.filters.dateRange ? this.data.filters.dateRange[1] : ''
		});
	},
	
	/**
	 * 关闭筛选抽屉
	 */
	onCloseFilter() {
		this.setData({
			showFilterDrawer: false
		});
	},
	
	/**
	 * 选择筛选选项
	 */
	onFilterSelect(e) {
		const type = e.currentTarget.dataset.type;
		const value = e.currentTarget.dataset.value;
		
		const newFilters = { ...this.data.filters };
		newFilters[type] = value;
		
		this.setData({
			filters: newFilters
		});
	},
	
	/**
	 * 选择开始日期
	 */
	onStartDateChange(e) {
		this.setData({
			startDate: e.detail.value
		});
	},
	
	/**
	 * 选择结束日期
	 */
	onEndDateChange(e) {
		this.setData({
			endDate: e.detail.value
		});
	},
	
	/**
	 * 应用筛选条件
	 */
	onApplyFilter() {
		const newFilters = { ...this.data.filters };
		
		if (this.data.startDate || this.data.endDate) {
			newFilters.dateRange = [
				this.data.startDate || '',
				this.data.endDate || ''
			];
		} else {
			newFilters.dateRange = null;
		}
		
		taskStore.setFilters(newFilters);
		
		taskStore.refreshTasks().then(() => {
			this._prepareTasksForBoard();
			this.onCloseFilter();
		}).catch(err => {
			console.error('[任务列表] 应用筛选失败:', err);
			this.onCloseFilter();
		});
	},
	
	/**
	 * 重置筛选条件
	 */
	onResetFilter() {
		const defaultFilters = {
			status: 'all',
			priority: 'all',
			assignee: 'all',
			dateRange: null,
			keyword: '',
			tags: []
		};
		
		this.setData({
			filters: defaultFilters,
			startDate: '',
			endDate: ''
		});
		
		taskStore.setFilters(defaultFilters);
		
		taskStore.refreshTasks().then(() => {
			this._prepareTasksForBoard();
		}).catch(err => {
			console.error('[任务列表] 重置筛选失败:', err);
		});
	},
	
	/**
	 * 格式化日期显示
	 */
	formatDate(timestamp) {
		if (!timestamp) return '';
		
		// 使用Day.js格式化时间
		return Day(timestamp).format('YYYY-MM-DD');
	},
	
	/**
	 * 判断截止日期状态
	 */
	getDueDateStatus(dueDate) {
		if (!dueDate) return '';
		
		const today = Day();
		const due = Day(dueDate);
		const diff = due.diff(today, 'day');
		
		if (diff < 0) return 'overdue';
		if (diff <= 2) return 'urgent';
		return '';
	},
	
	/**
	 * 获取状态文本
	 */
	getStatusText(status) {
		const statusMap = {
			'pending': '待处理',
			'processing': '处理中',
			'completed': '已完成',
			'suspended': '已暂停'
		};
		
		return statusMap[status] || status;
	}
});